{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第六章 决策树\n",
    ">- 与SVM一样， 决策树也是一种多功能的机器学习算法，\n",
    ">- 它可以现分类和回归任务， 甚至是多输出任务。\n",
    ">- 它们功能强大， 能够拟合复杂的数据集。\n",
    ">- 决策树同时也是随机森林的基本组成部分，后者是现今最强大的机器学习算法之一"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 决策树训练和可视化"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 下面的代码在鸢尾花数据集上训练了一个DecisionTreeClassifier："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.tree import DecisionTreeClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris = load_iris()\n",
    "X = iris['data'][:,2:]\n",
    "y = iris.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=2,\n",
       "                       max_features=None, max_leaf_nodes=None,\n",
       "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                       min_samples_leaf=1, min_samples_split=2,\n",
       "                       min_weight_fraction_leaf=0.0, presort=False,\n",
       "                       random_state=42, splitter='best')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tree_clf = DecisionTreeClassifier(max_depth=2, random_state=42)\n",
    "tree_clf.fit(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 要将决策树可视化，首先，使用export_graphviz（）方法输出一个图形定义文件，命名为iris_tree.dot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.tree import export_graphviz\n",
    "export_graphviz(\n",
    "    tree_clf,\n",
    "    out_file='./iris_tree.dot',\n",
    "    feature_names=iris.feature_names[2:],\n",
    "    class_names=iris.target_names,\n",
    "    rounded=True,\n",
    "    filled=True\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 使用graphviz包[1]中的dot命令行工具将这个.dot文件转换为其他格式， 例如PDF或PNG。 \n",
    ">```\n",
    "dot -Tpng iris_tree.dot -o iris_tree.png\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](iris_tree.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "# 做出预测"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 节点的samples属性统计它应用的训练实例数量。\n",
    "- 例如，有100个训练实例的花瓣长度大于2.45厘米（深度1，右），其中54个花瓣宽度小于1.75厘米（深度2，左）。\n",
    "- 节点的value属性说明了该节点上每个类别的训练实例数量：\n",
    "- 例如，右下节点应用在0个Setosa鸢尾、1个Versicolor鸢尾和45个Virginica鸢尾实例上。 \n",
    "- 最后， 节点的gini属性衡量其不纯度（impurity）：\n",
    "- 如果应用的所有训练实例都属于同一个类别，那么节点就是“纯”的（gini=0）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 基尼不纯度\n",
    "$$ G_i=1-\\sum_{k=1}^np_i,k^2 $$\n",
    "\n",
    "$p_i,k$是第i个节点上，类别为k的训练示例占比"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Scikit-Learn使用的是CART算法，该算法仅生成二叉树：非叶节点永远只有两个子节点（即问题答案仅有是或否）。\n",
    "- 但是，其他算法，比如ID3生成的决策树，其节点可以拥有两个以上的子节点。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](img/6-1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 如你所见，决策树是非常直观的，它们的决策也很容易解释，这类模型通常被称为白盒模型。\n",
    "- 与之相反的，我们稍后将会看到，随机森林或是神经网络被认为是一种黑盒模型。\n",
    "- 它们能做出很棒的预测，你也可以轻松检查它们在做出预测时执行的计算，\n",
    "- 然而，通常很难解释清楚它们为什么做出这样的预测。\n",
    "- 比如，如果神经网络说某个人出现在一张图片上，很难知道它实际上是基于什么做出的该预测：\n",
    "- 是模型识别出来了这个人的眼睛？ 嘴巴？ 鼻子？ 还是鞋子？ 甚至是她坐的沙发？\n",
    "- 相反，决策树提供了简单好用的分类规则，需要的话，你甚至可以手动应用这些规则（例如，花的分类） "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 估算类别概率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 0.90740741, 0.09259259]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 预测每种类别的概率\n",
    "tree_clf.predict_proba([[5, 1.5]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 直接预测类别\n",
    "tree_clf.predict([[5, 1.5]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "# CART训练算法 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 首先，使用单个特征k和阈值tk（例如，花瓣长度≤2.45厘米）将训练集分成两个子集。\n",
    "- k和阈值tk怎么选择？\n",
    "- 答案是产生出最纯子集（受其大小加权）的k和tk就是经算法搜索确定的（t，tk）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CART分类成本函数\n",
    "$$ J(k,t_k)=\\frac{m_{left}}{m}G_{left}+\\frac{m_{right}}{m}G_{right} $$\n",
    "- $G_{left/right}$衡量左/右子集的不纯度\n",
    "- $m_{left/right}$是左/右子集的实例是数量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 一旦成功将训练集一分为二，它将使用相同的逻辑，继续分裂子集，然后是子集的子集，\n",
    "- 依次循环递进。直到抵达最大深度（由超参数max_depth控制），\n",
    "- 或是再也找不到能够降低不纯度的分裂，它才会停止。 \n",
    "\n",
    "<small>CART是一种贪婪算法：从顶层开始搜索最优分裂，然后每层重复这个过程。几层分裂之后，它并不会检视这个分裂的不纯度是否为可能的最低值。贪婪算法通常会产生一个相当不错的解，但是不能保证是最优解。</small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 计算复杂度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 进行预测需要从根到叶遍历决策树。\n",
    "- 通常来说，决策树大致平衡，因此遍历决策树需要经历大约O（log2（m））个节点。（注：log2是以2为底的对数。等于log2（m）=log（m）/log（2）。）\n",
    "- 而每个节点只需要检查一个特征值，所以总体预测复杂度也只是O（log2（m）） ，与特征数量无关。 - 如此，即便是处理大型数据集，预测也很快。\n",
    "\n",
    "- 但是，训练时在每一个节点，算法都需要在所有样本上比较所有特征（如果设置了max_features会少一些）。这导致训练的复杂度为O（n×m log（m））。\n",
    "- 对于小型训练集（几千个实例以内），ScikitLearn可以通过对数据预处理（设置presort=True） 来加快训练，\n",
    "- 但是对于较大训练集而言， 可能会减慢训练的速度。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "# 基尼不纯度还是信息熵"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 默认使用的是基尼不纯度来进行测量，但是，你可以将超参数criterion设置为\"entropy\"来选择信息熵作为不纯度的测量方式。 \n",
    "- 如果所有的信息都相同，则熵为零。在机器学习中，它也经常被用作一种不纯度的测量方式：\n",
    ">如果数据集中仅包含一个类别的实例， 其熵为零。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 信息熵\n",
    "$$ H_i=-\\sum_{k=1}^np_{i,k}log(p_{i,k}) $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 例如上面深度2左侧节点的熵值等于$-\\frac{49}{54}log(\\frac{49}{54})-\\frac{5}{54}log(\\frac{5}{54})\\approx0.31$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 大多数情况下，它们并没有什么大的不同，产生的树都很相似。\n",
    "- 基尼不纯度的计算速度略微快一些，所以它是个不错的默认选择。\n",
    "- 它们的不同在于，基尼不纯度倾向于从树枝中分裂出最常见的类别，而信息熵则倾向于生产更平衡的树。 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 正则化超参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 决策树极少对训练数据做出假设（比如线性模型就正好相反，它显然假设数据是线性的）。\n",
    "- 如果不加以限制，树的结构将跟随训练集变化，<mark>严密拟合</mark>，并且很可能<mark>过度拟合</mark>。\n",
    "- 这种模型通常被称为非参数模型，这不是说它不包含任何参数（事实上它通常有很多参数），而是指在训练之前没有确定参数的数量，导致模型结构自由而紧密地贴近数据。 \n",
    "- 相应的参数模型，比如线性模型，则有预先设定好的一部分参数，因此其自由度受限，从而降低了过度拟合的风险（但是增加了拟合不足的风险） 。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 为避免过度拟合， 需要在训练过程中降低决策树的自由度。这个过程被称为正则化。\n",
    "- 可以限制决策树的最大深度来实现，在Scikit-Learn中，这由超参数max_depth控制\n",
    ">减小max_depth可使模型正则化， 而降低过度拟合的风险\n",
    "- DecisionTreeClassifier类还有一些其他的参数，同样可以限制决策树的形状:\n",
    "- min_samples_split（分裂前节点必须有的最小样本数），\n",
    "- min_samples_leaf（叶节点必须有的最小样本数量），\n",
    "- min_weight_fraction_leaf（跟min_samples_leaf一样，但表现为加权实例总数的占比），\n",
    "- max_leaf_nodes（最大叶节点数量），\n",
    "- 以及max_features（分裂每个节点评估的最大特征数量）。增大超参数min_*或是减小max_*将使模型正则化"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 下面是在卫星数据集（见第5章介绍） 上训练的两个决策树。 \n",
    "- 左图使用默认参数（即无约束） 来训练决策树，\n",
    "- 右图的决策树应用min_samples_leaf=4进行训练。\n",
    "- 很明显，左图模型过度拟合，右图的泛化效果更佳。\n",
    "![](img/6-3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 回归"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 代码示例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 生成一个带噪声的二次数据集\n",
    "import numpy as np\n",
    "np.random.seed(42)\n",
    "m = 200\n",
    "X = np.random.rand(m, 1)\n",
    "y = 4 * (X - 0.5) ** 2\n",
    "y = y + np.random.randn(m, 1) / 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeRegressor(criterion='mse', max_depth=2, max_features=None,\n",
       "                      max_leaf_nodes=None, min_impurity_decrease=0.0,\n",
       "                      min_impurity_split=None, min_samples_leaf=1,\n",
       "                      min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
       "                      presort=False, random_state=None, splitter='best')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeRegressor\n",
    "tree_reg = DecisionTreeRegressor(max_depth=2)\n",
    "tree_reg.fit(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "export_graphviz(\n",
    "    tree_reg,\n",
    "    out_file='./noise_reg_tree.dot',\n",
    "    rounded=True,\n",
    "    filled=True\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](noise_reg_tree.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- CART算法的工作原理跟前面介绍的大致相同，唯一不同在于，\n",
    "- 它分裂训练集的方式不是最小化不纯度，而是最小化MSE。 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CART回归成本函数\n",
    "$$ J(k,t_k)=\\frac{m_{left}}{m}MSE_{left}+\\frac{m_{right}}{m}MSE_{right} $$\n",
    "$$ MSE_{node}=\\sum_{i=node}(\\hat{y}_{node}-y^{(i)})^2 $$\n",
    "$$ \\hat{y}_{node}=\\frac{1}{m_{node}}\\sum_{i=node}y^{(i)} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1b246b662b0>]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(X, y, '.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 与分类任务一样， 决策树在处理回归任务时也很容易过度拟合。\n",
    "- 如果没有任何正则化（即使用默认超参数），\n",
    "- 你将得到如图左侧所示的预测结果，这显然对训练集严重过度拟合。\n",
    "- 只需要设置min_samples_leaf=10， 就能得到一个看起来合理得多的模型，"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeRegressor(criterion='mse', max_depth=None, max_features=None,\n",
       "                      max_leaf_nodes=None, min_impurity_decrease=0.0,\n",
       "                      min_impurity_split=None, min_samples_leaf=10,\n",
       "                      min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
       "                      presort=False, random_state=None, splitter='best')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tree_reg_1 = DecisionTreeRegressor()\n",
    "tree_reg_1.fit(X, y)\n",
    "\n",
    "tree_reg_2 = DecisionTreeRegressor(min_samples_leaf=10)\n",
    "tree_reg_2.fit(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'min_sample_leaf=10')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(11,4))\n",
    "plt.subplot(121)\n",
    "plt.plot(X, y, '.')\n",
    "X_temp = np.linspace(0, 1, 100).reshape(100, 1)\n",
    "y_temp = tree_reg_1.predict(X_temp)\n",
    "plt.plot(X_temp, y_temp, 'r-', label='$\\hat{y}$')\n",
    "plt.legend(loc='upper center')\n",
    "plt.title('无约束')\n",
    "\n",
    "plt.subplot(122)\n",
    "plt.plot(X, y, '.')\n",
    "X_temp = np.linspace(0, 1, 100).reshape(100, 1)\n",
    "y_temp = tree_reg_2.predict(X_temp)\n",
    "plt.plot(X_temp, y_temp, 'r-', label='$\\hat{y}$')\n",
    "plt.legend(loc='upper center')\n",
    "plt.title('min_sample_leaf=10')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 不稳定性"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 决策树青睐正交的决策边界（所有的分裂都与轴线垂直），这导致它们对训练集的旋转非常敏感。\n",
    "- 下面显示了一个简单的线性可分离数据集：\n",
    ">- 左图里，决策树可以很轻松分裂；\n",
    ">- 而到了右边，数据集旋转45°后，决策边界产生了不必要的卷曲。\n",
    ">- 虽然两个模型都看似完美拟合训练集，但是右侧模型很可能泛化不佳。 \n",
    ">\n",
    ">![](img/6-7.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 更概括地说， 决策树的主要问题是它们对训练数据中的小变化非常敏感。 \n",
    "- 例如，如果你从鸢尾花数据集中移除花瓣最宽的Versicolor鸢尾花（花瓣长4.8厘米，宽1.8厘米） ，然后重新训练一个决策树，你可能得到如图6-8所示的模型。 \n",
    "![](img/6-8.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
